package com.oa.process.service.impl;

import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.core.metadata.IPage;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.oa.model.process.ProcessTemplate;
import com.oa.model.process.ProcessType;
import com.oa.process.mapper.OaProcessTemplateMapper;
import com.oa.process.service.OaProcessService;
import com.oa.process.service.OaProcessTemplateService;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.oa.process.service.OaProcessTypeService;
import org.apache.tomcat.jni.Proc;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import org.springframework.util.CollectionUtils;
import org.springframework.util.StringUtils;

import javax.annotation.Resource;
import java.util.List;
import java.util.Map;
import java.util.stream.Collectors;

/**
 * <p>
 * 审批模板 服务实现类
 * </p>
 *
 * @author cloud_oa
 * @since 2024-10-26
 */
@Service
public class OaProcessTemplateServiceImpl extends ServiceImpl<OaProcessTemplateMapper, ProcessTemplate> implements OaProcessTemplateService {
    @Resource
    private OaProcessTemplateMapper processTemplateMapper;
    @Resource
    private OaProcessTypeService processTypeService;
    @Autowired
    private OaProcessService processService;

    @Override
    public IPage<ProcessTemplate> selectPage(Page<ProcessTemplate> pageParams) {
        LambdaQueryWrapper<ProcessTemplate>  queryWrapper = new LambdaQueryWrapper<ProcessTemplate>();

        queryWrapper.orderByDesc(ProcessTemplate::getId);

        IPage<ProcessTemplate> page = processTemplateMapper.selectPage(pageParams,queryWrapper);
        List<ProcessTemplate> processTemplateList = page.getRecords();

        List<Long> processTypeIdList = processTemplateList.stream().map(processTemplate ->
                processTemplate.getProcessTypeId()).collect(Collectors.toList());

        if(!CollectionUtils.isEmpty(processTypeIdList)){
            Map<Long, ProcessType> processTypeIdToProcessTypeMap = processTypeService.list(
                    new LambdaQueryWrapper<ProcessType>()
                            .in(ProcessType::getId, processTypeIdList))
                            .stream().collect(Collectors.toMap(ProcessType::getId, ProcessType -> ProcessType));

            for(ProcessTemplate processTemplate : processTemplateList){
                ProcessType processType = processTypeIdToProcessTypeMap.get(processTemplate.getProcessTypeId());
                if(null == processType){
                    continue;
                }
                processTemplate.setProcessTypeName(processType.getName());
            }
        }
        return page;

        //第一段代码的优点：
        //批量查询：使用List<Long>和Map<Long, ProcessType>来批量查询ProcessType，减少了数据库查询次数，提高了性能。
        //简洁性：使用Java Stream API来收集和转换数据，代码更加简洁。
        //顺序优化：通过orderByDesc(ProcessTemplate::getId)来指定排序规则，使得查询结果按照ID降序排列。
        //第一段代码的缺点：


        //第二段代码的优点：
        //简单直接：逐条查询ProcessType，逻辑简单直接，易于理解。
        //灵活性：逐条查询使得代码更加灵活，容易扩展。
        //第二段代码的缺点：
        //性能问题：每次循环都会进行一次数据库查询，当processTemplateList很大时，性能会明显下降。
        //效率低下：与批量查询相比，逐条查询效率较低。

        //// 1 调用mapper的方法实现分页查询
        //Page<ProcessTemplate> processTemplatePage = baseMapper.selectPage(pageParams, null);
        //
        //// 2 第一步分页查询返回分页数据 从分页数据获取列表集合
        //List<ProcessTemplate> processTemplateList = processTemplatePage.getRecords();
        //
        //// 3 遍历列表集合获取每个流程模板的id
        //for(ProcessTemplate processTemplate : processTemplateList){
        //    //得到每个对象的审批类型id
        //    Long processTypeId = processTemplate.getProcessTypeId();
        //    //根据审批类型id查询 审批对象名称
        //    LambdaQueryWrapper<ProcessType> wrapper = new LambdaQueryWrapper<>();
        //    wrapper.eq(ProcessType::getId,processTypeId);
        //
        //    ProcessType processType = processTypeService.getOne(wrapper);
        //
        //    if(processType == null){
        //        continue;
        //    }
        //
        //    //完成最终封装processTypeName
        //    processTemplate.setProcessTypeName(processType.getName());
        //}
        //return processTemplatePage;
    }

    /**
     * 发布流程模板
     * @param id
     */
    //批量数据处理
    @Transactional
    @Override
    public void publish(Long id) {
        ProcessTemplate processTemplate = this.getById(id);
        processTemplate.setStatus(1);
        processTemplateMapper.updateById(processTemplate);

    //    优先发布在线流程设计
        if(!StringUtils.isEmpty(processTemplate.getProcessDefinitionPath())){
            processService.deployByZip(processTemplate.getProcessDefinitionPath());
        }
    }
}
